package 字符串;

import java.util.Arrays;

import org.junit.Test;

/*

	 * 
	 * 传智播客
	 * 1. String str = "abc"; 直接赋值在字符串池里
	 * 2. String str = new String(); new出来的在堆里
	 * *字符串池* 是内存中的一块空间，用来保存 直接引用的字符串的地址
	 * 3.字符串不可变。，如果改变，说明一定是引用了一个新的地址
	 * 
	 * 
	 * 
	 * 高新强：
	 * String、StringBuffer、StringBuilder实现类，接口CharSequence
	 * String 本质是char[] 数组
	 * String str = null; 没有分配内存空间
	 * String str = ""; 分配内存空间 内容为空
	 * 
	 * 
	 *** str.substring( 起使角标(包括), 结束角标(之前的) );  截取字符串	
	 *
	 *** str.lastIndexOf("")； 获取指定字符，最后出现的位置(角标)
	 *
	 *** str.indexOf("String")； 获取指定字符，第一次出现的位置(角标)
	 *	 str.indexOf("String" , int)； 获取指定字符，第一次出现的位置(角标), 从int号角标开始
	 *
	 *** str.replace("要替换的str", "要换成的str")； 替换指定字符串
	 *
	 *** arrar[] = str.split("str")； 以" "为标志，切割字符串，数组接收
	 *
	 *** int str.length()； 字符串长度
	 *
	 * 1.char[] arrayA = str.toCharArray();   字符串 转成 char数组  （回文、 判断一串字符串有多少英文数字空格符号）
	 * 2. str.length(); 	获取字符串长度
	 * 3. str.charAt(int);	获取 指定角标 的 char内容
	 * 4. str.LowerCase();	英文字母 全变 小写
	 * 5. str.UpperCase();	英文字母 全变 大写
	 * 
	 * 	获取
	 1.获取 元素 第一次出现的位置
	 	str.indexOf("String")； 获取指定字符，第一次出现的位置(角标)
	 	str.indexOf("String" , int)； 获取指定字符，第一次出现的位置(角标), 从int号角标开始
	 2.获取 元素 最后一次 出现的位置
	 	str.lastIndexOf("")； 获取指定字符，最后出现的位置(角标)
	 	str.lastIndexOf("", int )； 获取指定字符，最后出现的位置(角标)
	 3.获取 索引处 内容
	 	str.charAt(int);	获取 指定角标 的 char内容
	 4.字符串 长度
	 	str.length();
	 * 
	 * 	判断
	 1. 是否包含 
	 	str.contains(""); Str是否包含 子字符串
	 2.是不是以一个str开头
	 	str.startsWith("String");
	 	str.startsWith("String", int); 从int开始，包含int
	 3.是不是以一个str结尾
	 	str.endsWith("String");
	 4.判断是否为空
	 	str.isEmpty();
	 * 
	 * 	转换  .数组 --> 字符 、字符 - ->  字符串
	 1.数组 --> 字符   char[] array = str.toCharArray,,, 字符 - ->  字符串   new String(char[] array);构造方法
	 *
	 *	替换字符串
	 1.str.replace("要替换的", "要换成的"); 
	 *
	 *	切割字符串
	 1. String[] arrayA = str.split(""); 以一个字符为标志 切割字符串   
	 *
	 *	截取字符串
	 1.str = str.substring(2);从 索引2 开始   到最后一个 之间的全部截取
	 2.str = str.substring(2, 5);从 索引2 开始   到索引5 之前的 截取 不包含5
	 *
	 *	去首尾空格
	 1.str.trim(); 去除 首尾空格
	 */

public class 关于String {
	
	@Test
	public void 作业1_循环实现trim() {
		/*
		 * 回文式做法
		 * 1.字符串 .toCharArray --> char[]
		 * 2.获取，start角标(从前面数第几个不是空格)，和end角标(从后面数第几个不是空格)
		 
		 	start ：从0开始   正序遍历
		  	2.1 遍历取出每一个char元素
		  	2.2 .equals("是不是空格")
		  	2.3 if(是空格) start++;
		  	2.4 else[遇到不是空格，代表没有空格了] break; 停止循环，这时已经取到第一个字母的角标了
		  	
		  	end ：从array.length-1(最后一个元素)开始   倒序遍历
		  	2.1 遍历取出每一个char元素
		  	2.2 .equals("是不是空格")
		  	2.3 if(是空格) end--; 
		  	2.4 else[遇到不是空格，代表没有空格了] break; 停止循环，这时已经取到最后一个空格的角标了    substring()  结束位置正好获取最后一个空格之前的内容
		 * 3.str = str.substring(startindex, endindex); 获取空格之间的内容(不是空格的部分)
		 * 4.输出str
		 */
		
		String str = "   java Android   ";
		int start = 0;
		int end = str.length() ;
		char[] array = str.toCharArray();
		for (int i = 0; i < array.length; i++) {
			if (array[i] == ' ') {
				start++;
			}else {
				break;
			}
		}
		
		for (int i = str.length()-1; i >= 0; i--) {
			if (array[i] == ' ') {
				end--;
			}else {
				break;
			}
		}
		System.out.println("start：" + start);
		System.out.println("end：" + end);
		str = str.substring(start, end);
		System.out.println(str);
	}
	
	@Test
	public void 作业1_循环实现trim_第二种做法() {
		String str = "   java Android   ";
		trim(str);
	}
	public static void trim(String str) {
		int start = 0;
		int end = str.length()-1;
		while (start <= end && str.charAt(start) == ' ') {
			start++;
		}
		while (start <= end && str.charAt(end) == ' ') {
			end--; // 倒着数  从后往前 取到第一个不是空格的地方(倒着数的第一个字母)
		}
		str=str.substring(start, end+1);
		System.out.println(str);
	}
	
	@Test
	public void 作业1_循环实现trim_第三种做法() {
		String str = "   java Android   ";
		int start = 0;
		int end = 0;
		char[] array = str.toCharArray();
		for (int i = 0; i < array.length; i++) {
			if (array[i] != ' ') { // 如果取到了不是空格的地方，就把这个角标给start
				start = i;
				break;
			}
		}
		
		for (int i = array.length-1; i >= 0 ; i--) {
			if (array[i] != ' ') { //
				end = i+1; // 倒数 从后往前  取到第一个不是空格的位置  （第一个字母），substring的endindex是取到之前的，所以end+1 
				break;
			}
		}
		str=str.substring(start, end);
		System.out.println(str);
	}
	
	
	@Test
	public void 作业2_循环实现小写转化() {
		
		/*
		 * 1.字符串 .toCharArray --> char[]
		 * 2.遍历数组，取出每一个char元素
		 * 3.如果是大写字母，asc数字范围 >=65 && <=90
		 * 4.那个元素 +32 就是asc里对应的小写字母
		 * 5.再把 数组 --> 字符串  str = new String(array);
		 * 6.输出 str
		 * 
		 */
		
		String str = "I Love Java!";
		char[] array = str.toCharArray();
		for (int i = 0; i < array.length; i++) {
			if (array[i] >= 65 && array[i] <= 90) {
				array[i] += 32;
			}
		}
		//System.out.println(Arrays.toString(array));
		str = new String(array); 
		System.out.println(str);
	}
	
	@Test
	/*
	 * 1.字符串 .split  切 成 字符串数组
	 * 2.遍历 字符串数组
	 * 3.把获取的每个字符串数组.toCharArray变成字符数组，付给一个数组arrayA
	 * 4.遍历arrayA,
	 * 5.取出每个元素  比较 是不是 ASC表里的大小写字母的范围，是的话sum++ (sum提前创建)
	 * 6.打印sum
	 */
	public void 作业3_split统计字母个数() {
		int sum=0;
		String str = "this is my homework! I must finish it!";
		String[] array = str.split(" ");
		System.out.println(Arrays.toString(array));
		for (int i = 0; i < array.length; i++) {
			char[] arrayA = array[i].toCharArray();
			for (int j = 0; j < arrayA.length; j++) {
				if( (arrayA[j] >= 65 && arrayA[j] <= 90) || arrayA[j] >=97 && arrayA[j] <= 122 ) {
					sum++;
				}
			}
		}
		System.out.println("英文个数总共有：" + sum + "个");
	}
	
	@Test
	public void 练习() {
		
		// toCharArray();
		char[] array = "Hello Java!".toCharArray();
//		for (char eacharray : array) {
//			System.out.println(eacharray);
//		}
		
		//数组 --> 字符串
		String str = new String( array) ;
		System.out.println(str);
		
		// 替换字符串  replace
		String str2 = str.replace(" ", "_");
		System.out.println(str2);
		
		// 切割字符串 split  数组接收
		String[] str3 = "Hello,Java,I'm,Sunny".split(",");
//		for (String string : str3) {
//			System.out.println(string);
//		}
		
		// 截取字符串
		String str4 = "Hello,Java,I'm,Sunny";
		
		String str41 = str4.substring(11);
		System.out.println(str41);
		
		String str42 = str4.substring(0,11);   // From索引0  to索引11 之前的  ，不包含11
		System.out.println(str42);
		
		// 去除首尾空格
		String str5 = " hello java ٩(๑>◡<๑)۶";System.out.println(str5);
		str5 = str5.trim();
		System.out.println(str5);
	}
		
	// 1. 获取以hello开头，的那段字符串 ，的后缀名
	@Test
	public void 截取指定字符串() {
		
		/*
		 * 1.split以";" 切割字符串 存进String数组
		 * 2.遍历数组，取出每个元素 
		 * 3.判断每个元素，是不是以"hello"开头 if(array[i].startsWith("hello") )
		 * 4.index, 获取 最后一个"."的位置index =   lastIndexOf(".")
		 * 5.从index开始截取后面所有的
		 * 6.把截取出来的赋给一个字符串
		 * 7.打印这个字符串
		 * 
		 */
//		//System.out.println("abcABC".toUpperCase());
//		
//		String str =  "abc.java;hello.myxq;hello.txt.java;hello.class";
//		
//		// 1.先把字符串分开
//		String[] strArray = str.split(";");
//		
//		//2.判断是否以hello开头
//		// 2.1遍历 取出每个字符串
//		for (String name : strArray) {
//			// 判断是否已hello开头
//			// 2.2 startsWith("");是否以指定字符串开头
//			if (name.startsWith("hello")) {
//				// 3.是的话，获取这个字符串  最一个句点 .  	的位置 (因为要截取据点后面的) 	lastIndexOf(".")
//				int index = name.lastIndexOf(".");
//				// 4.截取指定位置的字符串		substring( 起使角标(包括), 结束角标(之前的)  );
//				String newname = name.substring(index+1); // index是句点.   index+1就从据点之后那个开始截取
//				System.out.println(newname);
//			}
//			
//		}
		
		String str =  "abc.java;hello.myxq;hello.txt.java;hello.class";
		String[] arrayStr = str.split(";");
		for (int i = 0; i < arrayStr.length; i++) {
			if (arrayStr[i].startsWith("hello")) {
				int index = arrayStr[i].lastIndexOf(".");
				String newStr = arrayStr[i].substring(index+1);
				System.out.println(newStr);
			}
		}
	} //截取指定字符串()
	
	
	@Test
	public void 字符串_首字母大写() {
		String str =  "sgx";
		// 1.截取首字母
		String firstletter = str.substring(0,1);
		// 2.首字母转大写
		firstletter = firstletter.toUpperCase();
		// 3.截取后面的字母
		String lastletter = str.substring(1);
		// 4.后面的代码全转小写
		lastletter = lastletter.toLowerCase();
		// 5.把两部分拼接
		System.out.println(firstletter+lastletter);
		isNull(lastletter);
	} //字符串_首字母大写()
	
	// 3. 静态方法 判断字符串是不是空的(地址和内容)
	public static boolean isNull(String str) {
		//1.判断
		// 1.1 地址不为null
		// 1.2 内容不为空      翻译：不能 (空字符串是不是trim之后的字符串)     trim去除首位空格 再把值赋给变量
		//2.不是空：false ,,, 是空：true
		if (str != null && !"".equals(str.trim())) {
			System.out.println("不是空字符串");
			return false;
		}else {
			System.out.println("是空字符串");
			return true;
		}
	} //静态方法 判断字符串是不是空的(地址和内容)

	// 4. 去除的首尾空格 trim();
	@Test
	public void 去除首尾空格() {
		String str =  " sgx ";
		System.out.println(str);
		str = str.trim();
		System.out.println(str);
	}
	
	// 5. 替换字符 去除空格 split();
	@Test
	public void 替换字符_去除空格() {
		String str =  " s g x ";
		System.out.println(str);
		str= str.replace(" ", "");
		System.out.println(str);
	}
	
}
